{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:06.114757Z",
     "start_time": "2025-02-28T18:20:06.111217Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=True)  # 把sparse改为True看看\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                                {'city': '上海', 'temperature': 60},\n",
    "                                {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:06.241967Z",
     "start_time": "2025-02-28T18:20:06.225886Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Compressed Sparse Row sparse matrix of dtype 'float64'\n",
      "\twith 6 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(res)\n",
    "    print('-' * 50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-' * 50)\n",
    "    print(res.toarray())  #稀疏矩阵转换为数组\n",
    "    print('-' * 50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:06.272467Z",
     "start_time": "2025-02-28T18:20:06.264208Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(data)  #稀疏存储，只记录非零位置\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:06.328196Z",
     "start_time": "2025-02-28T18:20:06.320343Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '我喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  #jieba分词好的中文文本\n",
    "    print('-' * 50)\n",
    "    print(c1)  #把分词好的文本打印出来\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())  #把处理好后的特征名称打印出来\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.287174Z",
     "start_time": "2025-02-28T18:20:06.371088Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n",
      "Loading model from cache C:\\Users\\25571\\AppData\\Local\\Temp\\jieba.cache\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading model cost 0.903 seconds.\n",
      "Prefix dict has been built successfully.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "#TfidfVectorizer 是 Python 中 scikit-learn 库提供的一个工具类，用于将文本数据转换为 TF-IDF 特征矩阵。它是文本预处理和特征提取的核心工具之一，主要作用是将原始文本（如句子、段落、文档）转换为机器学习模型可直接处理的数值形式（向量），同时通过 TF-IDF 算法突出文本中的关键信息。\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(type(data))\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.295785Z",
     "start_time": "2025-02-28T18:20:07.288174Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    out = mm.transform([[1, 2, 3, 4], [6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.303132Z",
     "start_time": "2025-02-28T18:20:07.296786Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "source": "(1 - 60) / 30",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.312056Z",
     "start_time": "2025-02-28T18:20:07.305131Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9666666666666666"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.],\n",
    "                              [2., 4., 2.],\n",
    "                              [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)  #方差\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data = stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.319672Z",
     "start_time": "2025-02-28T18:20:07.313056Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.325807Z",
     "start_time": "2025-02-28T18:20:07.320672Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#如何求方差\n",
    "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "code",
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.345579Z",
     "start_time": "2025-02-28T18:20:07.326807Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform(data)\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.351471Z",
     "start_time": "2025-02-28T18:20:07.346578Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.48029737e-16  7.40148683e-17  7.40148683e-17]\n",
      "[1. 1. 1.]\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "source": "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.357244Z",
     "start_time": "2025-02-28T18:20:07.352471Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "code",
   "source": "(1 - 2.333) / np.sqrt(1.55555)",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.363489Z",
     "start_time": "2025-02-28T18:20:07.359241Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(-1.068779614944516)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "markdown",
   "source": [
    "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:None\n",
    "    \"\"\"\n",
    "    # np.nan替换为均值\n",
    "    #mean, median, most_frequent(众数), constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.370788Z",
     "start_time": "2025-02-28T18:20:07.364490Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "source": "11 / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.376412Z",
     "start_time": "2025-02-28T18:20:07.371789Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.6666666666666665"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "code",
   "source": "np.nan + 10",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.380924Z",
     "start_time": "2025-02-28T18:20:07.377412Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 18
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（特征变少）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.387615Z",
     "start_time": "2025-02-28T18:20:07.381925Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "--------------------------------------------------\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5],\n",
    "                               [6, 3, 0, 8],\n",
    "                               [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum())  #最初数据每一列的方差，求和\n",
    "    print('-' * 50)\n",
    "    pca = PCA(n_components=0.99)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差和\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-' * 50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.409156Z",
     "start_time": "2025-02-28T18:20:07.388615Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 20
  },
  {
   "cell_type": "code",
   "source": "22 / 29.333333333333336",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:07.413962Z",
     "start_time": "2025-02-28T18:20:07.410156Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7499999999999999"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 21
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x = np.random.rand(10000)  #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t, x, 'g.', label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T18:20:08.951079Z",
     "start_time": "2025-02-28T18:20:07.414962Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 22
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
